/******************************************************************************
* Copyright (c) 2002, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
****************************************************************************/
package org.eclipse.gmf.runtime.draw2d.ui.figures;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import org.eclipse.draw2d.ArrowLocator;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.ConnectionLocator;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.PolylineConnection;
import org.eclipse.draw2d.RotatableDecoration;
import org.eclipse.draw2d.RoutingAnimator;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;
import org.eclipse.gmf.runtime.draw2d.ui.internal.figures.ConnectionLayerEx;
import org.eclipse.gmf.runtime.draw2d.ui.internal.figures.DelegatingLayout;
import org.eclipse.gmf.runtime.draw2d.ui.internal.routers.OrthogonalRouter;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.widgets.Display;
/**
* This is an extension of the <code>PolylineConnection</code> class to support avoid obstructions, smoothness
* and jump-links behavior.
*
* @author sshaw
*/
public class PolylineConnectionEx extends PolylineConnection implements IPolygonAnchorableFigure {
private RotatableDecoration startDecoration, endDecoration;
private static Rectangle LINEBOUNDS = Rectangle.SINGLETON;
private static int TOLERANCE = 3;
private static Rectangle EMPTY_BOUNDS = new Rectangle(0,0,0,0);
/**
* No smoothness
*/
public static final int SMOOTH_NONE = 0x0000;
/**
* Some smoothness
*/
public static final int SMOOTH_LESS = 0x0010;
/**
* Normal smoothness
*/
public static final int SMOOTH_NORMAL = 0x0020;
/**
* More exagerated smoothness
*/
public static final int SMOOTH_MORE = 0x0040;
/**
* Flag indicates whether the connection will attempt to "jump"
* other connection below it in the z-order.
*/
public static final int JUMPLINK_FLAG_BELOW = 0x4000; // jump links below
/**
* Flag indicates whether the connection will attempt to "jump"
* other connection above it in the z-order.
*/
public static final int JUMPLINK_FLAG_ABOVE = 0x8000; // jump links above
/**
* Flag indicates whether the connection will attempt to "jump"
* all other connections regardless of z-order.
*/
public static final int JUMPLINK_FLAG_ALL =
JUMPLINK_FLAG_BELOW | JUMPLINK_FLAG_ABOVE;
private static final int SMOOTH_FACTOR_LESS = 15;
private static final int SMOOTH_FACTOR_NORMAL = 30;
private static final int SMOOTH_FACTOR_MORE = 50;
// extra routing styles
// avoid intersection with other nodes
private static final int ROUTE_AVOID_OBSTACLE = 0x0100;
// always use closest route to the destination
private static final int ROUTE_CLOSEST_ROUTE = 0x0200;
// jump other links
private static final int ROUTE_JUMP_LINKS = 0x0400;
// jump link flags
private static final int JUMPLINK_FLAG_SMOOTH = 0x0800;
// indicates whether the jump links are smooth or not
private static final int JUMPLINK_FLAG_ANGLEIN = 0x1000;
// indicates whether the link is angled inwards
private static final int JUMPLINK_FLAG_ONBOTTOM = 0x2000;
private static final int JUMPLINK_DEFAULT_SMOOTHNESS = 30;
// round bendpoints radius (applicable only for rectilinear routing with no
// smoothness) default value 0 means that bendpoints are not rounded
private int roundedBendpointsRadius = 0;
// if rounding bendpoints fails (it shouldn't happen), then roundedBendpointsRadius is set to 0 so
// connection can be routed without rounded corners, and origRoundedBendpointsRad gets
// the original value of roundedBendpointsRadius (so it can be used in future attempts)
private int origRoundedBendpointsRad = 0;
private long styleBits;
private JumpLinkSet jumpLinkSet;
private Hashtable connectionAnchors;
/**
* When rounded bendpoints is turned on, keeping track of arcs that have smaller size than the default
*/
private Hashtable<Integer, Integer> rForBendpointArc;
static private final String szAnchor = ""; //$NON-NLS-1$
/**
* A dimension used by the isFeedbackLayer() method to check if we are
* on a feedback layer.
*/
private static final Dimension dimCheck = new Dimension(100, 100);
/**
* This method checks if we are on a feedback layer by comparing
* the value of a Dimension with the value after translating it
* into relative coordinates.
*
* @return true if we are on a feedback layer, which means the
* results after translating were the same as not translating, or false
* if we are not on a feedback layer.
*/
private boolean isFeedbackLayer() {
Dimension copied = dimCheck.getCopy();
translateToRelative(copied);
return dimCheck.equals(copied);
}
/**
*
*/
public PolylineConnectionEx() {
styleBits =
JUMPLINK_FLAG_BELOW
| JUMPLINK_FLAG_SMOOTH
| JUMPLINK_FLAG_ANGLEIN;
setLayoutManager(new DelegatingLayout());
addRoutingListener(RoutingAnimator.getDefault());
}
/**
* Provides a utility function for dirtying the jump links and repainting the line.
*/
public void refreshLine() {
dirtyJumpLinks();
repaint();
}
/**
* Add a point to the polyline connection.
*/
public void addPoint(Point pt) {
super.addPoint(pt);
refreshLine();
}
/**
* Calculate and store the tolerance value for determining whether the line contains a point or not.
*
* @param isFeedbackLayer see the isFeedbackLayer() method
*/
private int calculateTolerance(boolean isFeedbackLayer) {
Dimension absTol = new Dimension(TOLERANCE, 0);
if (!isFeedbackLayer) {
MapModeUtil.getMapMode(this).DPtoLP(absTol);
}
return absTol.width + lineWidth / 2;
}
/**
* Returns the bounds which holds all the points in this
* polyline connection. Returns any previously existing
* bounds, else calculates by unioning all the children's
* dimensions.
*
* @return Bounds to hold all the points.
*/
public Rectangle getBounds(){
if (bounds == null) {
if (getSmoothFactor() != 0) {
bounds = getSmoothPoints().getBounds();
bounds.expand(lineWidth/2, lineWidth/2);
for(int i=0; i<getChildren().size(); i++) {
IFigure child = (IFigure)getChildren().get(i);
bounds.union(child.getBounds());
}
}
else
super.getBounds();
boolean isFeedbackLayer = isFeedbackLayer();
int calculatedTolerance = calculateTolerance(isFeedbackLayer);
Dimension jumpLinkSize = calculateJumpLinkSize(isFeedbackLayer);
// extend the boundary slightly by the jumplinks height value
bounds.expand(jumpLinkSize.height + calculatedTolerance, jumpLinkSize.height + calculatedTolerance);
}
return getSourceAnchor() != null && getTargetAnchor() != null ? bounds : EMPTY_BOUNDS;
}
/**
* Method getShallowBounds.
* @return Rectangle
*/
public Rectangle getSimpleBounds(){
Point s = getStart();
Point e = getEnd();
Point start = new Point(Math.min(s.x, e.x), Math.min(s.y, e.y));
Dimension d = new Dimension(Math.abs(s.x-e.x), Math.abs(s.y-e.y));
return new Rectangle(start.x, start.y, d.width, d.height);
}
/**
* Determine if the polyline connection contains a given point.
* @param x int value of the point to check containment of
* @param y int value of the point to check containment of.
* @return boolean true indicating containment, false otherwise.
*/
public boolean containsPoint(int x, int y) {
boolean isFeedbackLayer = isFeedbackLayer();
int calculatedTolerance = calculateTolerance(isFeedbackLayer);
LINEBOUNDS.setBounds(getBounds());
LINEBOUNDS.expand(calculatedTolerance,calculatedTolerance);
if (!LINEBOUNDS.contains(x, y))
return false;
int ints[] = getSmoothPoints().toIntArray();
for (int index = 0; index < ints.length - 3; index += 2) {
if (lineContainsPoint(ints[index], ints[index + 1],
ints[index + 2], ints[index + 3], x, y,
isFeedbackLayer))
return true;
}
List children = getChildren();
for (int i = 0; i < children.size(); i++) {
if (((IFigure)children.get(i)).containsPoint(x, y))
return true;
}
return false;
}
private boolean lineContainsPoint(
int x1, int y1,
int x2, int y2,
int px, int py,
boolean isFeedbackLayer) {
LINEBOUNDS.setSize(0,0);
LINEBOUNDS.setLocation(x1,y1);
LINEBOUNDS.union(x2,y2);
int calculatedTolerance = calculateTolerance(isFeedbackLayer);
LINEBOUNDS.expand(calculatedTolerance,calculatedTolerance);
if (!LINEBOUNDS.contains(px,py))
return false;
double v1x, v1y, v2x, v2y;
double numerator, denominator;
double result = 0;
if( x1 != x2 && y1 != y2 ) {
v1x = (double)x2 - x1;
v1y = (double)y2 - y1;
v2x = (double)px - x1;
v2y = (double)py - y1;
numerator = v2x * v1y - v1x * v2y;
denominator = v1x * v1x + v1y * v1y;
result = numerator * numerator / denominator;
}
// if it is the same point, and it passes the bounding box test,
// the result is always true.
return result <= calculatedTolerance * calculatedTolerance;
}
/**
* Calculate the line segment index for a given point. This is important
* for the drag tracker that add's bendpoints on a connection.
*
* @param x the x value in relative coordinates
* @param y the y value in relative coordinates
* @return the index of the line segment that is nearest to the given point.
*/
public int findLineSegIndexOfPoint(int x, int y) {
calculateTolerance(isFeedbackLayer());
return PointListUtilities.findNearestLineSegIndexOfPoint(getPoints(), new Point(x, y));
}
/**
* Returns points for this connection. If the smooth factor is turned on,
* then calculate the approximated smooth polyline for display or other
* purposes. If bendpoints need to be rounded, calculates points taking that
* into account. In that case, if calculateAprox is true, it will also
* calculate points that approximate corner arcs. If it is false, it will
* replace each bendpoint with two points that represent start and end of an
* arc. In any case, calculated points are not persisted.
*
* @param calculateAppox
* If true, and rounding bendpoints is on, then calculate points
* that approximate bendpoint arc.
* @return Resulting <code>PointList</code>. In case when sooth factor is
* on, it is a polyline approximation of a bezier curve calculated
* based on the smoothness factor.
* @since 1.2
*/
public PointList getSmoothPoints(boolean calculateAppox) {
if (getSmoothFactor() > 0) {
return PointListUtilities.calcSmoothPolyline(getPoints(), getSmoothFactor(), PointListUtilities.DEFAULT_BEZIERLINES);
} else if (isRoundingBendpoints()){
PointList result = getRoundedCornersPoints(calculateAppox);
if (result == null) {
// this shouldn't happen, but if it does happen that rounded corners
// cannot be calculated set radius to 0 and use original bendpoints
// (will produce non-rounded rectangular connection)
origRoundedBendpointsRad = roundedBendpointsRadius;
roundedBendpointsRadius = 0;
result = PointListUtilities.copyPoints(getPoints());
}
return result;
} else {
return PointListUtilities.copyPoints(getPoints());
}
}
/**
* See {@link #getSmoothPoints(boolean calculateAppoxPoints)}
*/
public PointList getSmoothPoints() {
return getSmoothPoints(true);
}
/**
* Insert a point at the given index into the polyline connection.
*/
public void insertPoint(Point pt, int index) {
super.insertPoint(pt, index);
refreshLine();
}
/**
* Override the figure method "outlineShape" to draw the actual polyline connection shape.
* Special code to regenerate the jumplinks, draw the polyline smooth, and round the bendpoints
* is also done during this method call.
*/
protected void outlineShape(Graphics g) {
PointList displayPoints = getSmoothPoints(false);
Hashtable<Point, Integer> originalDisplayPoints = null;
if (isRoundingBendpoints()) {
// If rounded bendpoints feature is turned on, remember the original points, will be
// needed later.
originalDisplayPoints = new Hashtable<Point, Integer>();
for (int i = 0; i < displayPoints.size(); i++) {
originalDisplayPoints.put(displayPoints.getPoint(i), new Integer(i));
}
}
int incline = calculateJumpLinkIncline(isFeedbackLayer());
if (shouldJumpLinks()) {
regenerateJumpLinks();
JumpLinkSet pJumpLinkSet = getJumpLinkSet();
if (pJumpLinkSet != null && pJumpLinkSet.m_pJumpLinks != null) {
int nSmoothNess = 0;
if (isJumpLinksSmooth())
nSmoothNess = JUMPLINK_DEFAULT_SMOOTHNESS;
boolean bOnBottom = isJumpLinksOnBottom();
ListIterator linkIter = pJumpLinkSet.m_pJumpLinks.listIterator();
while (linkIter.hasNext()) {
JumpLink pJumpLink = (JumpLink) linkIter.next();
PointList jumpLinkPoints = PointListUtilities.routeAroundPoint(
displayPoints,
pJumpLink.m_ptIntersect,
pJumpLink.m_nHeight,
pJumpLink.m_nWidth,
nSmoothNess,
incline,
!bOnBottom);
if (jumpLinkPoints != null)
displayPoints = jumpLinkPoints;
}
}
}
if (!isRoundingBendpoints()) {
g.drawPolyline(displayPoints);
if (origRoundedBendpointsRad > 0) {
// we unsuccessfully tried to do rounding, allow the next routing to try again.
roundedBendpointsRadius = origRoundedBendpointsRad;
origRoundedBendpointsRad = 0;
}
} else {
// In originalDisplayPoints, each bendpoint will be replaced with two points: start and end point of the arc.
// If jump links is on, then displayPoints will also contain points identifying jump links, if any.
int i = 1;
int rDefault = getRoundedBendpointsRadius();
while (i < displayPoints.size() - 1) {
// Consider points at indexes i-1, i, i+1.
int x0 = 0, y0 = 0;
boolean firstPointAssigned = false;
if (shouldJumpLinks()) {
boolean containsPoint2;
boolean containsPoint3;
PointList jumpLinkPoints = new PointList();
do {
// First, check if point at index i or i+1 is start point of a jump link (if the point is not in original points).
// If so, draw a polyline ending at the last point of the jump link.
containsPoint2 = true;
containsPoint3 = true;
if (i < displayPoints.size()) {
containsPoint2 = originalDisplayPoints.containsKey(displayPoints.getPoint(i));
if (i < displayPoints.size() - 1) {
containsPoint3 = originalDisplayPoints.containsKey(displayPoints.getPoint(i+1));
}
}
if (!containsPoint2 || !containsPoint3) {
// start adding jump link points
jumpLinkPoints.addPoint(displayPoints.getPoint(i-1));
Point p; // next point to be added to jump link points
int j; // index of the next point in jump link
if (!containsPoint2) {
// jump link starts somewhere on the segment before the arc begins
j = i;
p = displayPoints.getPoint(i);
} else {
// jump link starts within an arc; it means that one part of the arc will be replaced with
// a segment between points at i and i-1, and another part is replaced with the jump link,
j = i + 1;
p = displayPoints.getPoint(i+1);
jumpLinkPoints.addPoint(displayPoints.getPoint(i));
}
do {
jumpLinkPoints.addPoint(p);
j++;
p = displayPoints.getPoint(j);
} while (!originalDisplayPoints.containsKey(p) && j < displayPoints.size() - 1);
// Now, check if p is start point of a line segment or an arc. In first case, index of p in
// the original list is even, in second it's odd.
int origIndex = ((Integer)originalDisplayPoints.get(p)).intValue();
firstPointAssigned = false;
if (origIndex % 2 == 0) {
// p is start point of a segment, it means that the jump link finished somewhere within the arc,
// so one part of the arc is replaced with the jump link, and another will be replaced with a segment.
jumpLinkPoints.addPoint(p);
i = j + 1;
} else {
// p is start point of an arc, the last point in jump link polyline becomes the first point for
// the drawing that follows (p could be the last point too)
x0 = jumpLinkPoints.getLastPoint().x;
y0 = jumpLinkPoints.getLastPoint().y;
i = j;
firstPointAssigned = true;
}
// Reason for the loop: we cannot be sure that points at newly founded i=j+1, or i+1 (when i == j) are
// not starting points of a new jump link;
// in most of the cases, though, the loop will execute just one step
// Jump link algorithm sometimes inserts duplicate points, we need to get rid of those.
while (i < displayPoints.size() - 1 &&
displayPoints.getPoint(i).equals(displayPoints.getPoint(i+1))) {
i++;
}
}
} while (!containsPoint2 || !containsPoint3);
if (jumpLinkPoints != null) {
// draw jump link
g.drawPolyline(jumpLinkPoints);
}
}
if (i < displayPoints.size() - 1) { // if we still didn't reach the end after drawing jump link polyline
// Draw a segment starting at index i-1 and ending at index i,
// and arc with starting point at index i and ending point at index i+1.
// But first, find points at i-1, i and i+1.
if (!firstPointAssigned) {
x0 = displayPoints.getPoint(i-1).x;
y0 = displayPoints.getPoint(i-1).y;
}
int x1;;
int y1;
// If points at i-1 and i are equal (could happen if jump link algorithm
// inserts a point that already exists), just skip the point i
while (i < displayPoints.size() - 1 &&
x0 == displayPoints.getPoint(i).x && y0 == displayPoints.getPoint(i).y) {
i++;
}
if (i < displayPoints.size() - 1) {
x1 = displayPoints.getPoint(i).x;
y1 = displayPoints.getPoint(i).y;
} else {
break;
}
// The same goes for point at i and i+1
int x2;
int y2;
while (i + 1 < displayPoints.size() - 1 &&
x1 == displayPoints.getPoint(i+1).x && y1 == displayPoints.getPoint(i+1).y) {
i++;
}
if (i < displayPoints.size() - 1) {
x2 = displayPoints.getPoint(i+1).x;
y2 = displayPoints.getPoint(i+1).y;
} else {
break;
}
// Draw the segment
g.drawLine(x0, y0, x1, y1);
// Find out if arc size is default, or if it had to be decreased because of lack of space
int r = rDefault;
Point p = displayPoints.getPoint(i);
int origIndex = ((Integer)originalDisplayPoints.get(p)).intValue();
Object o = rForBendpointArc.get(new Integer((origIndex+1)/2));
if (o != null) {
r = ((Integer)o).intValue();
}
// Find out the location of enclosing rectangle (x, y), as well as staring angle of the arc.
int x, y;
int startAngle;
if (x0 == x1 && x1 < x2) {
x = x1;
y = y1 - r;
if (y1 > y2) {
startAngle = 90;
} else {
startAngle = 180;
}
} else if (x0 > x1 && x1 > x2) {
x = x2;
y = y2 - r;
if (y1 > y2) {
startAngle = 180;
} else {
startAngle = 90;
}
} else if (x0 == x1 && x1 > x2) {
if (y1 > y2) {
x = x2 - r;
y = y2;
startAngle = 0;
} else {
x = x1 - 2*r;
y = y1 - r;
startAngle = 270;
}
} else { // x0 < x1 && x1 < x2
if (y1 > y2) {
x = x2 - 2*r;
y = y2 - r;
startAngle = 270;
} else {
x = x1 - r;
y = y1;
startAngle = 0;
}
}
// Draw the arc.
g.drawArc(x, y, 2*r, 2*r, startAngle, 90);
i+=2;
}
}
// Draw the last segment.
g.drawLine(displayPoints.getPoint(displayPoints.size()-2), displayPoints.getLastPoint());
}
}
/**
* Set the line width of the polyline connection.
*/
public void setLineWidth(int w) {
bounds = null;
super.setLineWidth(w);
}
/**
* Sets the list of points to be used by this polyline connection.
* Removes any previously existing points.
*
* @param points New set of points.
*/
public void setPoints(PointList points) {
super.setPoints(points);
dirtyAllJumpLinks();
refreshLine();
}
/**
* Calculate the jumplink dimensions.
*/
private static final int JUMPLINK_DEFAULT_WIDTH = 25;
private static final int JUMPLINK_DEFAULT_HEIGHT = 10;
/**
* Calculate the size of the jump link.
*
* @param isFeedbackLayer the <code>boolean</code> that determines if mapping of the coordinates will occur.
* This is necessary since the feedback layer doesn't not go through the zooming or mapmode scaling.
*
* @return <code>Dimension</code> that is the jump link size
*/
private Dimension calculateJumpLinkSize(boolean isFeedbackLayer) {
Dimension jumpDim = new Dimension(JUMPLINK_DEFAULT_WIDTH, JUMPLINK_DEFAULT_HEIGHT);
if (!isFeedbackLayer) {
MapModeUtil.getMapMode(this).DPtoLP(jumpDim);
}
return jumpDim;
}
/**
* Calculate the jumplink incline
*
* @param isFeedbackLayer the <code>boolean</code> that determines if mapping of the coordinates will occur.
* This is necessary since the feedback layer doesn't not go through the zooming or mapmode scaling.
*/
private int calculateJumpLinkIncline(boolean isFeedbackLayer) {
if (isJumpLinksAngledIn())
return calculateJumpLinkSize(isFeedbackLayer).width / 5;
return 0;
}
/**
* Dirty all connection jump links in the diagram
*/
public void dirtyAllJumpLinks()
{
IFigure pParent = getParent();
if (pParent instanceof ConnectionLayerEx)
((ConnectionLayerEx)pParent).dirtyJumpLinks(getBounds());
}
/**
* Inner class for storing the specific JumpLink information.
*/
protected class JumpLink {
/**
* intersection point value
*/
public Point m_ptIntersect;
/**
* width of the jump link
*/
public int m_nWidth;
/**
* height of the jump link
*/
public int m_nHeight;
/**
* distance along the polyline
*/
public int m_nDistance;
}
/**
* Inner class for storing the set of JumpLink's associated with the
* polyline connection.
*/
protected class JumpLinkSet {
/**
* Default constructor
*/
public JumpLinkSet() {
m_bDirty = true;
m_pJumpLinks = null;
}
/**
* Determines if the jump links need to be regenerated.
*
* @return <code>boolean</code> <code>true</code> if jump links need to be regenerated, <code>false</code> otherwise.
*/
public boolean isDirty() {
return m_bDirty;
}
/**
* Sets the dirty flag back to false and notifies the connection layer
* that it has been cleaned.
*
* @param connect <code>Connection</code> whose jump links need to be regenerated.
*/
protected void cleanJumpLinks(Connection connect) {
m_bDirty = false;
IFigure pParent = connect.getParent();
if (pParent instanceof ConnectionLayerEx)
((ConnectionLayerEx)pParent).cleanJumpLinks();
}
/**
* Sets the jump links set as being dirty so that they will be regenerated
* again at display time.
*/
public void dirtyJumpLinks() {
m_bDirty = true;
}
/**
* Regenerates the jump links again according to the current arrangement of connections
* on the diagram.
*
* @param connect <code>Connection</code> whose jump links need to be regenerated.
* @return <code>boolean</code> <code>true</code> if jump links were regenerated, <code>false</code> otherwise.
*/
public boolean regenerateJumpLinks(Connection connect) {
// check if we need to regenerate the jump link info
if (isDirty()) {
// regenerate the points where jump links will occur
calculateIntersections(connect);
cleanJumpLinks(connect);
return true;
}
return false;
}
/**
* Inner class useed to compare two jump links to see which is further
* along the polyline connection.
*/
private class CompareDistance implements Comparator {
public int compare(Object obj1, Object obj2) {
JumpLink j1 = (JumpLink) obj1;
JumpLink j2 = (JumpLink) obj2;
if (j1.m_nDistance < j2.m_nDistance)
return -1;
else
if (j1.m_nDistance > j2.m_nDistance)
return 1;
return 0;
}
}
/**
* Sort the jump links according to their distance along the polyline
* connection line.
*/
private void sortByDistance() {
Object[] jumpArray = m_pJumpLinks.toArray();
Arrays.sort(jumpArray, new CompareDistance());
for (int i = 0; i < m_pJumpLinks.size(); i++)
m_pJumpLinks.set(i, jumpArray[i]);
}
/**
* Calculate the intersections that occur between this connection and all the
* other connections on the diagram.
*
* @param connect <code>Connection</code> to calculate intersections with other connections in the layer.
*/
private void calculateIntersections(Connection connect) {
// regenerate the points where jump links will occur
IFigure pParent = connect.getParent();
if (m_pJumpLinks != null)
m_pJumpLinks = null;
PointList tmpLine = getSmoothPoints();
long jumpType = (styleBits & JUMPLINK_FLAG_ALL);
// only check intersections with connect views which are below this one.
List children = pParent.getChildren();
int nIndex = children.indexOf(connect);
ListIterator childIter = children.listIterator();
boolean bForwards = true;
if (jumpType != JUMPLINK_FLAG_ALL)
{
childIter = children.listIterator(nIndex);
if (jumpType == JUMPLINK_FLAG_BELOW)
bForwards = false;
}
boolean isFeedbackLayer = isFeedbackLayer();
Dimension jumpLinkSize = calculateJumpLinkSize(isFeedbackLayer);
while (bForwards ? childIter.hasNext() : childIter.hasPrevious()) {
IFigure figure =
(IFigure) (bForwards ? childIter.next() : childIter.previous());
PointList checkLine = null;
if (figure != connect) {
if (figure instanceof PolylineConnectionEx)
checkLine = ((PolylineConnectionEx) figure).getSmoothPoints();
else
if (figure instanceof Connection)
checkLine = PointListUtilities.copyPoints(((Connection) figure).getPoints());
if (checkLine != null) {
PointList intersections = new PointList();
PointList distances = new PointList();
if (m_pJumpLinks == null)
m_pJumpLinks = new ArrayList(intersections.size());
if (PointListUtilities.findIntersections(tmpLine, checkLine, intersections, distances)) {
for (int i = 0; i < intersections.size(); i++) {
double dist1 = intersections.getPoint(i).getDistance(tmpLine.getFirstPoint());
double dist2 = intersections.getPoint(i).getDistance(tmpLine.getLastPoint());
double dist3 = intersections.getPoint(i).getDistance(checkLine.getFirstPoint());
double dist4 = intersections.getPoint(i).getDistance(checkLine.getLastPoint());
double minDist = Math.min(Math.min(dist1,dist2), Math.min(dist3,dist4));
if (minDist > jumpLinkSize.width/2){
addJumpLink(intersections.getPoint(i), distances.getPoint(i).x, isFeedbackLayer);
}
}
}
}
}
}
// check to see if we need to combine intersects that are close together
combineCloseLinks(tmpLine);
}
/**
* Add a new jump with the given intersection point and distance along the polyline
* connection line.
* @param ptIntersect
* @param nDistance
* @param isFeedbackLayer see the isFeedbackLayer() method
*/
private void addJumpLink(Point ptIntersect, int nDistance, boolean isFeedbackLayer) {
JumpLink pNewJumpLink = new JumpLink();
pNewJumpLink.m_ptIntersect = new Point(ptIntersect);
Dimension jumpLinkSize = calculateJumpLinkSize(isFeedbackLayer);
pNewJumpLink.m_nWidth = jumpLinkSize.width;
pNewJumpLink.m_nHeight = jumpLinkSize.height;
pNewJumpLink.m_nDistance = nDistance;
m_pJumpLinks.add(pNewJumpLink);
}
/**
* If there are two consecutive jump links that are close together with a certain
* tolerance value, then combine them into one larger jump link.
*
* @param tmpLine the <code>PointList</code>
*/
private void combineCloseLinks(PointList tmpLine) {
if (m_pJumpLinks == null || m_pJumpLinks.size() < 2)
return;
Dimension jumpLinkSize = calculateJumpLinkSize(isFeedbackLayer());
int nCurrentWidth = jumpLinkSize.width;
ArrayList jumpLinks = new ArrayList(m_pJumpLinks.size());
// sort the jump links by distance
sortByDistance();
jumpLinks.addAll(m_pJumpLinks);
m_pJumpLinks.clear();
ListIterator linkIter = jumpLinks.listIterator();
// combine intersects that are close together and increase jump link width
JumpLink pLastJumpLink = (JumpLink) linkIter.next();
JumpLink pPrevJumpLink = null;
final int nDeltaMin = jumpLinkSize.width * 4 / 3;
while (pLastJumpLink != null) {
JumpLink pJumpLink = null;
int nDelta = 0;
if (linkIter.hasNext()) {
pJumpLink = (JumpLink) linkIter.next();
nDelta = pJumpLink.m_nDistance - pLastJumpLink.m_nDistance;
}
if ((nDelta > nDeltaMin) || pJumpLink == null) {
JumpLink pNewJumpLink = new JumpLink();
pNewJumpLink.m_nHeight = jumpLinkSize.height;
pNewJumpLink.m_nWidth = nCurrentWidth;
pNewJumpLink.m_nDistance = 0;
pNewJumpLink.m_ptIntersect = new Point(pLastJumpLink.m_ptIntersect);
if (pPrevJumpLink != null) {
// need to recalc the intersection point
long nNewDistance =
pPrevJumpLink.m_nDistance
+ ((pLastJumpLink.m_nDistance - pPrevJumpLink.m_nDistance) / 2);
pNewJumpLink.m_ptIntersect = new Point();
PointListUtilities.pointOn(tmpLine, nNewDistance, LineSeg.KeyPoint.ORIGIN, pNewJumpLink.m_ptIntersect);
}
m_pJumpLinks.add(pNewJumpLink);
nCurrentWidth = jumpLinkSize.width;
pPrevJumpLink = null;
} else {
if (pPrevJumpLink == null)
pPrevJumpLink = pLastJumpLink;
nCurrentWidth += jumpLinkSize.width - (nDeltaMin - nDelta);
}
pLastJumpLink = pJumpLink;
}
}
private boolean m_bDirty;
private List m_pJumpLinks;
}
/**
* Get the smoothness factor for the polyline connection. A value of 0
* indicates that there is no smoothness.
*
* @return the value is one of 0 - no smoothing, SMOOTH_FACTOR_LESS - rounded edges,
* SMOOTH_FACTOR_NORMAL - more curved look, SMOOTH_FACTOR_MORE - exagerated curving
*/
private final int getSmoothFactor() {
int smoothStyle = getSmoothness();
if (smoothStyle == SMOOTH_LESS)
return SMOOTH_FACTOR_LESS;
else
if (smoothStyle == SMOOTH_NORMAL)
return SMOOTH_FACTOR_NORMAL;
else
if (smoothStyle == SMOOTH_MORE)
return SMOOTH_FACTOR_MORE;
return 0;
}
/**
* Sets the smoothness factor of this Connection that is reflected when the polyline is rendered.
*
* @param smooth the value is one of SMOOTH_NONE - no smoothing, SMOOTH_LESS - rounded edges,
* SMOOTH_NORMAL - more curved look, SMOOTH_MORE - exagerated curving.
*/
public final void setSmoothness(int smooth) {
// always turn off all smoothing
styleBits &= ~(SMOOTH_LESS | SMOOTH_NORMAL | SMOOTH_MORE);
if (smooth == SMOOTH_LESS
|| smooth == SMOOTH_NORMAL
|| smooth == SMOOTH_MORE) {
styleBits |= smooth;
}
}
/**
* Gets the smoothness factor.
*
* @return the value is one of SMOOTH_NONE - no smoothing, SMOOTH_LESS - rounded edges,
* SMOOTH_NORMAL - more curved look, SMOOTH_MORE - exagerated curving.
*/
public final int getSmoothness() {
if ((styleBits & SMOOTH_LESS) != 0)
return SMOOTH_LESS;
else
if ((styleBits & SMOOTH_NORMAL) != 0)
return SMOOTH_NORMAL;
else
if ((styleBits & SMOOTH_MORE) != 0)
return SMOOTH_MORE;
return 0;
}
/**
* Determines if this polyline connection is using closest distance routing or not.
*
* @return <code>boolean</code> <code>true</code> if it should be using closest distance routing,
* <code>false</code otherwise.
*/
public final boolean isClosestDistanceRouting() {
return ((styleBits & ROUTE_CLOSEST_ROUTE) != 0);
}
/**
* Determines if this polyline connection is using avoid obstruction routing or not.
*
* @return <code>boolean</code> <code>true</code> if it should be using avoid obstruction routing,
* <code>false</code otherwise.
*/
public final boolean isAvoidObstacleRouting() {
return ((styleBits & ROUTE_AVOID_OBSTACLE) != 0);
}
/**
* Set the overall routing styles for this polyline connection.
*
* @param closestDistance <code>boolean</code> <code>true</code> if it should be using closest distance routing,
* <code>false</code otherwise
* @param avoidObstacles <code>boolean</code> <code>true</code> if it should be using avoid obstruction routing,
* <code>false</code otherwise
*/
public void setRoutingStyles(
final boolean closestDistance,
final boolean avoidObstacles) {
if (closestDistance)
styleBits |= ROUTE_CLOSEST_ROUTE;
else {
styleBits &= ~ROUTE_CLOSEST_ROUTE;
}
if (avoidObstacles) {
if (!closestDistance)
styleBits |= ROUTE_CLOSEST_ROUTE;
styleBits |= ROUTE_AVOID_OBSTACLE;
} else
styleBits &= ~ROUTE_AVOID_OBSTACLE;
}
/**
* Determines if the bendpoints should be rounded.
* This option is available only when orthogonal router is used, and
* when smoothness is not selected.
*
* @return true if the option is selected and the current router is orthogonal
* @since 1.2
*/
public boolean isRoundingBendpoints() {
if (roundedBendpointsRadius > 0 && getSmoothFactor() == 0) {
return getConnectionRouter() instanceof OrthogonalRouter;
}
return false;
}
/**
* Sets the parameter indicating the arc radius for rounded bendpoints.
*
* @param radius
* @since 1.2
*/
public void setRoundedBendpointsRadius(int radius) {
roundedBendpointsRadius = radius;
if (origRoundedBendpointsRad > 0) {
origRoundedBendpointsRad = radius;
}
}
/**
* Returns the parameter indicating the arc radius for rounded bendpoints.
*
* @return the parameter indicating the arc radius for rounded bendpoints
* @since 1.2
*/
public int getRoundedBendpointsRadius() {
return MapModeUtil.getMapMode(this).DPtoLP(roundedBendpointsRadius);
}
/**
* Determines if this polyline connection should use the jump links methodology
* or not.
*
* @return <code>boolean</code> <code>true</code> if this connection should support jump links,
* <code>false</code> otherwise.
*/
public final boolean shouldJumpLinks() {
if ((styleBits & ROUTE_JUMP_LINKS) != 0) {
IFigure pParent = getParent();
if (pParent instanceof ConnectionLayerEx)
return ConnectionLayerEx.shouldJumpLinks();
return true;
}
return false;
}
/**
* Turns on or off the jump links functionality.
*
* @param on the <code>boolean</code> <code>true</code> if this connection should support jump links,
* <code>false</code> otherwise.
*/
public void setJumpLinks(boolean on) {
if (on)
styleBits |= ROUTE_JUMP_LINKS;
else
styleBits &= ~ROUTE_JUMP_LINKS;
}
/**
* Set the jump links styles associated with the jump links functionality.
*
* @param jumpType value can be one of <code>PolylineConnectionEx.JUMPLINK_FLAG_BELOW</code>,
* <code>PolylineConnectionEx.JUMPLINK_FLAG_ABOVE</code> or <code>PolylineConnectionEx.JUMPLINK_FLAG_ALL</code>
* @param curved the <code>boolean</code> indicating if <code>true</code> the jump link should be curved (semi-circle)
* or if <code>false</code> it should be straight (rectangular).
* @param angleIn the <code>boolean</code> if <code>true</code> indicating the sides of the jump link are angled or
* if <code>false</code> then the sides of the jump link are straight.
* @param onBottom the <code>boolean</code> <code>true</code> it will be oriented on the bottom of the connection,
* <code>false</code> it will oriented on top.
*/
public void setJumpLinksStyles(
int jumpType,
boolean curved,
boolean angleIn,
boolean onBottom) {
styleBits &= ~JUMPLINK_FLAG_ALL;
styleBits |= jumpType;
if (curved)
styleBits |= JUMPLINK_FLAG_SMOOTH;
else
styleBits &= ~JUMPLINK_FLAG_SMOOTH;
if (angleIn)
styleBits |= JUMPLINK_FLAG_ANGLEIN;
else
styleBits &= ~JUMPLINK_FLAG_ANGLEIN;
if (onBottom)
styleBits |= JUMPLINK_FLAG_ONBOTTOM;
else
styleBits &= ~JUMPLINK_FLAG_ONBOTTOM;
dirtyJumpLinks();
}
/**
* Determines if the jump links are smooth or not.
*
* @return <code>boolean</code> indicating if <code>true</code> the jump link should be curved (semi-circle) or
* if <code>false</code> it should be straight (rectangular).
*/
public final boolean isJumpLinksSmooth() {
return ((styleBits & JUMPLINK_FLAG_SMOOTH) != 0);
}
/**
* Determines if the jump links are angled in or not.
*
* @return <code>boolean</code> if <code>true</code> indicating the sides of the jump link are angled or
* if <code>false</code> then the sides of the jump link are straight.
*/
public final boolean isJumpLinksAngledIn() {
return ((styleBits & JUMPLINK_FLAG_ANGLEIN) != 0);
}
/**
* Determines if the jump links are on the bottom of the polyline connection or not.
*
* @return <code>boolean</code> <code>true</code> it will be oriented on the bottom of the connection,
* <code>false</code> it will oriented on top.
*/
public final boolean isJumpLinksOnBottom() {
return ((styleBits & JUMPLINK_FLAG_ONBOTTOM) != 0);
}
/**
* Dirty the jump links in this polyline connection.
*/
void dirtyJumpLinks() {
JumpLinkSet pJumpLinkSet = getJumpLinkSet();
if (pJumpLinkSet != null) {
pJumpLinkSet.dirtyJumpLinks();
}
}
/**
* Regenerate all the jump links in this polyline connection.
*/
private boolean regenerateJumpLinks() {
JumpLinkSet pJumpLinkSet = getJumpLinkSet();
if (pJumpLinkSet != null) {
return pJumpLinkSet.regenerateJumpLinks(this);
}
return false;
}
/**
* Gets the set of all the jump links in this polyline connection.
*/
private JumpLinkSet getJumpLinkSet() {
if (shouldJumpLinks()) {
if (jumpLinkSet == null) {
jumpLinkSet = new JumpLinkSet();
}
} else {
jumpLinkSet = null;
}
return jumpLinkSet;
}
/* (non-Javadoc)
* @see org.eclipse.gmf.runtime.draw2d.ui.figures.IPolygonAnchorableFigure#getPolygonPoints()
*/
public PointList getPolygonPoints() {
return getSmoothPoints();
}
/* (non-Javadoc)
* @see org.eclipse.gmf.runtime.draw2d.ui.figures.IAnchorableFigure#getConnectionAnchor(java.lang.String)
*/
public ConnectionAnchor getConnectionAnchor(String terminal) {
ConnectionAnchor connectAnchor =
(ConnectionAnchor) getConnectionAnchors().get(terminal);
if (connectAnchor == null) {
if (terminal.equals(szAnchor)) {
// get a new one - this figure doesn't support static anchors
connectAnchor = createDefaultAnchor();
getConnectionAnchors().put(terminal,connectAnchor);
}
else {
connectAnchor = createAnchor(BaseSlidableAnchor.parseTerminalString(terminal));
}
}
return connectAnchor;
}
/* (non-Javadoc)
* @see org.eclipse.gmf.runtime.draw2d.ui.figures.IAnchorableFigure#getConnectionAnchorTerminal(org.eclipse.draw2d.ConnectionAnchor)
*/
public String getConnectionAnchorTerminal(ConnectionAnchor c) {
if (c instanceof BaseSlidableAnchor) {
return ((BaseSlidableAnchor) c).getTerminal();
}
if (getConnectionAnchors().containsValue(c)) {
Iterator iter = getConnectionAnchors().keySet().iterator();
String key;
while (iter.hasNext()) {
key = (String) iter.next();
if (getConnectionAnchors().get(key).equals(c))
return key;
}
}
getConnectionAnchor(szAnchor);
return szAnchor;
}
/* (non-Javadoc)
* @see org.eclipse.gmf.runtime.draw2d.ui.figures.IAnchorableFigure#getSourceConnectionAnchorAt(org.eclipse.draw2d.geometry.Point)
*/
public ConnectionAnchor getSourceConnectionAnchorAt(Point p) {
return createConnectionAnchor(p);
}
/* (non-Javadoc)
* @see org.eclipse.gmf.runtime.draw2d.ui.figures.IAnchorableFigure#getTargetConnectionAnchorAt(org.eclipse.draw2d.geometry.Point)
*/
public ConnectionAnchor getTargetConnectionAnchorAt(Point p) {
return createConnectionAnchor(p);
}
/**
* Creates the default Slidable anchor with a reference point at the center
* of the figure's bounds
*
* @return - default SlidableAnchor, relative reference the center of the figure
*/
protected ConnectionAnchor createDefaultAnchor() {
return new BaseSlidableAnchor(this);
}
/**
* Creates a slidable anchor at the specified point (from the ratio of the
* reference's coordinates and bounds of the figure
*
* @param p - relative reference for the <Code>SlidableAnchor</Code>
* @return a <code>SlidableAnchor</code> for this figure with relative reference at p
*/
protected ConnectionAnchor createAnchor(PrecisionPoint p) {
if (p==null)
// If the old terminal for the connection anchor cannot be resolved (by SlidableAnchor) a null
// PrecisionPoint will passed in - this is handled here
return createDefaultAnchor();
return new BaseSlidableAnchor(this, p);
}
/**
* Returns a new anchor for this node figure.
*
* @param p <code>Point</code> on the figure that gives a hint which anchor to return.
* @return <code>ConnectionAnchor</code> reference to an anchor associated with the
* given point on the figure.
*/
protected ConnectionAnchor createConnectionAnchor(Point p) {
if (p == null) {
return getConnectionAnchor(szAnchor);
}
else {
Point temp = p.getCopy();
translateToRelative(temp);
PrecisionPoint pt = BaseSlidableAnchor.getAnchorRelativeLocation(temp, getBounds());
return createAnchor(pt);
}
}
/**
* Checks whether the <PrecisionPoint> p which is a candidate for a relative reference
* for the <Code>SlidableAnchor</Code> belongs to the area where the default anchor
* must be created
*
* @param p
* @return <code>boolean</code> <code>true</code> if <PrecisionPoint> belongs to the area where the default anchor must be
* created, <code>false</code> otherwise
*/
protected boolean isDefaultAnchorArea(PrecisionPoint p) {
return p.preciseX >= getSlidableAnchorArea()/2 && p.preciseX <= 1 - getSlidableAnchorArea()/2 &&
p.preciseY >= getSlidableAnchorArea()/2 && p.preciseY <= 1 - getSlidableAnchorArea()/2;
}
/**
* Returns the connectionAnchors.
* @return Hashtable
*/
protected Hashtable getConnectionAnchors() {
if (connectionAnchors == null)
connectionAnchors = new Hashtable(1);
return connectionAnchors;
}
/**
* Specifies how large the area of the figure's bounds where <Code>SlidableAnchor</Code>
* will be created. The result number: 0<=result<=1
*
* @return the size of the area of the figure's bounds
*/
protected double getSlidableAnchorArea() {
return 0.25;
}
/*
* (non-Javadoc)
* @see org.eclipse.draw2d.IFigure#setForegroundColor(org.eclipse.swt.graphics.Color)
*/
public void setForegroundColor(Color fg) {
super.setForegroundColor(fg);
if (getTargetDecoration() != null){
getTargetDecoration().setForegroundColor(fg);
}
if (getSourceDecoration() != null){
getSourceDecoration().setForegroundColor(fg);
}
}
/**
* Sets the decoration to be used at the start of the {@link Connection}.
*
* @param dec the new source decoration
* @param locator the <code>ConnectionLocator</code> that allows placement of the source
* <code>RotableDecoration</code>.
*/
public void setSourceDecoration(RotatableDecoration dec, ConnectionLocator locator) {
if (getSourceDecoration() != null)
remove(getSourceDecoration());
startDecoration = dec;
if (dec != null) {
add(dec, locator);
}
}
/**
* Sets the decoration to be used at the end of the {@link Connection}.
*
* @param dec the new target decoration
* @param locator the <code>ConnectionLocator</code> that allows placement of the target
* <code>RotableDecoration</code>.
*/
public void setTargetDecoration(RotatableDecoration dec, ConnectionLocator locator) {
if (getTargetDecoration() != null)
remove(getTargetDecoration());
endDecoration = dec;
if (dec != null) {
add(dec, locator);
}
}
/**
* @return the target decoration - possibly null
*/
protected RotatableDecoration getTargetDecoration() {
return endDecoration;
}
/**
* @return the source decoration - possibly null
*/
protected RotatableDecoration getSourceDecoration() {
return startDecoration;
}
/* (non-Javadoc)
* @see org.eclipse.draw2d.PolylineConnection#setTargetDecoration(org.eclipse.draw2d.RotatableDecoration)
*/
public void setTargetDecoration(RotatableDecoration dec) {
if (getTargetDecoration() != null)
remove(getTargetDecoration());
endDecoration = dec;
if (dec != null) {
add(dec, new ArrowLocator(this, ConnectionLocator.TARGET));
}
}
/* (non-Javadoc)
* @see org.eclipse.draw2d.PolylineConnection#setSourceDecoration(org.eclipse.draw2d.RotatableDecoration)
*/
public void setSourceDecoration(RotatableDecoration dec) {
if (getSourceDecoration() != null)
remove(getSourceDecoration());
startDecoration = dec;
if (dec != null) {
add(dec, new ArrowLocator(this, ConnectionLocator.SOURCE));
}
}
/**
* Sets the line dash style.
* @see org.eclipse.swt.graphics.LineAttributes#dash
* @param dashes The dashes attribute.
*/
public void setLineDash(int[] dashes) {
float [] floatDashes = new float[dashes.length];
for (int i = 0; i < dashes.length; i++) {
floatDashes[i] = dashes[i];
}
setLineDash(floatDashes);
}
/**
* Currently we cannot create bendpoints with avoid obstructions
* routing style turned on. Hence we need to define a special cursor
* to give user feedback about the disabled bendpoint editing
*/
static private final Cursor NO_COMMAND_SPECIAL_CURSOR =
new Cursor(Display.getDefault(), SWT.CURSOR_ARROW);
/**
* Overriden to display special cursor when needed. Fix for bug #145467
*/
public Cursor getCursor() {
if (isAvoidObstacleRouting())
return NO_COMMAND_SPECIAL_CURSOR;
return super.getCursor();
}
/**
* Returns the list of points for this connection when rounded bendpoints
* option is selected. Each bendpoint in the result list is replaced by
* start and end points of the arc, and if calculateApproxPoints is true, it
* will also have arc approximation points in between.
*
* @param calculateAppoxPoints
* Indicates if arcs replacing bendpoints should be approximated
* @return List of connection points when rounded bendpoints option is on
* @since 1.2
*/
public PointList getRoundedCornersPoints(boolean calculateAppoxPoints) {
if (rForBendpointArc != null) {
rForBendpointArc.clear();
} else {
rForBendpointArc = new Hashtable<Integer, Integer>();
}
return PointListUtilities.calcRoundedCornersPolyline(getPoints(), getRoundedBendpointsRadius(),
rForBendpointArc, calculateAppoxPoints);
}
}